package com.wakey.rtcs.utils;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * string工具类
 * @author Albert
 *
 */
public class StringUtil {

	public StringUtil() {
	}

	/**
	 * 判断NULL
	 * 
	 * @param value
	 * @return
	 */
	public static boolean isNull(String value) {
		try {
			if (value == null)
				return true;
			if ("null".equals(value))
				return true;
			if (value.trim().length() == 0)
				return true;
			else
				return false;
		} catch (Exception e) {
			return false;
		}
	}

	/**
	 * 判断对象是否为NULL，如为Null转化为空字符串
	 * 
	 * @param value
	 * @return
	 */
	public static String repNullToStr(String val) {
		return val == null ? "" : val;
	}

	/**
	 * 处理非法字符（定义0-31的ASCII码为非法字符）
	 * 
	 * @param s
	 * @return
	 */
	public static boolean isIllegalChar(String s) {
		boolean flag = false;
		char[] dest = s.trim().toCharArray();
		for (int i = 0; i < dest.length; i++) {
			if (((int) dest[i] > 0 && (int) dest[i] < 32)) {
				// Debug("含有非法字符!" + (int) dest[i]);
				flag = true;
				break;
			}
		}
		return flag;
	}

	/**
	 * 判断是否为正数
	 * 
	 * @param value
	 * @return
	 */
	public static boolean checkNum(String value) {
		try {
			if (value != null && value.trim().length() > 0) {
				if ((value.charAt(0) == '-')) {
					return false;
				} else {
					String[] temp = value.split("\\.");
					if (temp.length > 2) {
						return false;
					}
					value = value.replaceAll("\\.", "");
					char[] dest = value.trim().toCharArray();
					for (int i = 0; i < dest.length; i++) {
						if (!Character.isDigit(dest[i])) {
							return false;
						}
					}
				}
			} else {
				return false;
			}
		} catch (Exception e) {
			return false;
		}
		return true;
	}

	/**
	 * 替换String中的字符串. 在标准的String类中只有将String中的某一个字符替换成另一个字符，该函数可以将String
	 * 中的某一字符串替换成另一个字符串.
	 * 
	 * @param str0 源字符串 tag 将要被替换的字符串 news 将要替换的字符串
	 * @return 将源字符串替换后的字符串
	 */
	public static String replace(String str, String tag, String news) {
		if (str == null || str.length() == 0 || tag == null || tag.length() == 0)
			return (str);
		String ret = str, temp = "";
		String l_str;
		int len_s = str.length();
		int len_t = tag.length();
		int pos_1 = 0, pos_2 = 0;
		int i = 0;
		while (i < len_s) {
			if (i >= (len_s - len_t))
				l_str = str.substring(i);
			else
				l_str = str.substring(i, i + len_t);
			if (l_str.equals(tag)) {
				pos_2 = i;
				temp = temp + str.substring(pos_1, pos_2) + news;
				i = i + len_t;
				pos_1 = i;
			} else
				i++;
		}
		if (pos_1 < len_s)
			temp = temp + str.substring(pos_1);

		if (temp.length() > 0)
			ret = temp;

		return (ret);
	}

	/**
	 * 查找某一字符串包含另一字符串的个数. 此处规定已匹配过的字符
	 * 
	 * @param str1 源字符串 str2 将要被替换的字符串
	 * @return 包含的个数
	 */
	public static int hasStr(String str1, String str2) {
		int sum = 0;
		String sTemp = new String(str1);
		while (sTemp.indexOf(str2) != -1) {
			sum++;
			sTemp = sTemp.substring(sTemp.indexOf(str2) + str2.length());
		}
		return sum;
	}

	/**
	 * 将字符串转化成gb2312的编码格式
	 */
	public static String changeEncoding(String strChinese, String soureceEncoding, String targetEncoding) {
		if (strChinese == null)
			return "";
		try {
			return new String(strChinese.trim().getBytes(soureceEncoding), targetEncoding);
		} catch (Exception e) {
			return "";
		}
	}

	/**
	 * 将一个字符串根据一个标示拆分成一个字符串数组.例如",1,2,3,"如果使用“,”分解，将被分成长度为5的字符串数组
	 * 
	 * @param source 源字符串,str 拆分标示字符。
	 * @return 被拆分的字符串
	 */
	public static String[] toArray(String source, String str) {
		Vector vResult = new Vector();
		if (source == null || source.equals(""))
			return new String[0];
		if (str == null || "".equals(str))
			return new String[] { source };
		int pos1 = 0;
		int pos2 = 0;
		pos2 = source.indexOf(str);
		String strItem = "";
		if (pos2 < 0) {
			pos2 = source.length();
			strItem = source;
		}
		while (pos2 >= pos1 && pos1 < source.length()) {
			strItem = source.substring(pos1, pos2);
			vResult.add(strItem);
			pos1 = pos2 + 1;
			pos2 = source.indexOf(str, pos1);
			if (pos2 <= 0)
				pos2 = source.length();

		}
		return toArray(vResult);
	}

	public static String[] split(String source, String token) {
		return stringToArray(source, token);
	}

	public static String[] splitString(String source, String token) {
		return stringToArray(source, token);
	}

	public static String[] stringToArray(String source, String str) {

		Vector vResult = new Vector();
		if (source == null || source.equals("")) {
			String tmp[] = { "" };
			return tmp;
		}

		if (str == null || "".equals(str))
			return new String[] { source };
		int pos1 = 0;
		int pos2 = 0;
		pos2 = source.indexOf(str);
		String strItem = "";
		if (pos2 < 0) {
			pos2 = source.length();
			strItem = source;
		}
		while (pos2 >= pos1 && pos1 <= source.length()) {
			if (pos2 == source.length() && pos1 == source.length()) {
				strItem = source.substring(pos2);
				vResult.add(strItem);
				break;
			}
			strItem = source.substring(pos1, pos2);
			vResult.add(strItem);
			pos1 = pos2 + str.length();
			pos2 = source.indexOf(str, pos1);
			if (pos2 <= 0)
				pos2 = source.length();
		}
		return toArray(vResult);
	}

	public static String[] toArray(Vector vec) {
		int intSize = vec.size();
		String str[] = new String[intSize];
		for (int i = 0; i < intSize; i++)
			str[i] = vec.elementAt(i).toString();
		return str;
	}

	public static String[] clearElement(String[] sources, String str) {
		sources = StringUtil.moveToEnd(sources, str);
		int size = 0;
		for (; size < sources.length; size++) {
			if (sources[size].equals(str))
				break;
		}
		String[] temp = new String[size];
		for (int i = 0; i < size; i++)
			temp[i] = sources[i];
		return temp;
	}

	/**
	 * 将一个String[]中的某种字符串移到数组的末尾.
	 * 
	 * @param sources 源字符串数组 str 将要移动的字符串
	 * @return 移动后的字符串数组
	 */
	public static String[] moveToEnd(String[] sources, String str) {
		int head = 0;
		int end = sources.length - 1;
		while (head != end) {
			while (head != end) {
				if (sources[head].equals(str))
					break;
				head++;
			}
			while (head != end) {
				if (!sources[end].equals(str))
					break;
				end--;
			}
			if (head != end) {
				String temp = sources[head];
				sources[head] = sources[end];
				sources[end] = temp;
			}
		}
		return sources;
	}

	/**
	 * 将字符串数组转化成int型数组.
	 * 
	 * @param sources 源字符串数组
	 * @return int[]
	 */
	public static int[] pareInts(String[] sources) {
		int[] temp = new int[sources.length];
		for (int i = 0; i < sources.length; i++) {
			temp[i] = Integer.parseInt(sources[i]);
		}
		return temp;
	}

	/**
	 * 将数组vector转化为字符串
	 */
	public static String toString(Vector vec, String str) {
		String s = "";
		for (int i = 0; i < vec.size(); i++) {
			if (i != 0)
				s += str;
			s += vec.elementAt(i).toString().trim();
		}
		return s;
	}

	/**
	 * 将数组[]转化为字符串
	 */
	public static String toString(String[] scr, String str) {
		String s = "";
		for (int i = 0; i < scr.length; i++) {
			if (i != 0)
				s += str;
			s += scr[i];
		}
		return s;
	}

	/**
	 * 从字符串中取出一个单词
	 */
	public static String getWord(String str, int index) throws Exception {
		if (index < 1)
			throw new Exception("getWord error,index less than 1");
		String word = null;
		for (int i = 0; i < index; i++) {
			word = StringUtil.getFirstWord(str, true);
			str = str.substring(word.length());
		}
		return word;
	}

	/**
	 * 从字符串中取出第一个单词,并且将分隔符（'，'、‘ ’）也作为一个单词
	 */
	public static String getFirstWord(String str, boolean hasSeparator) throws Exception {
		if (str.equals(""))
			return "";
		char ch = str.charAt(0);
		if (ch == '(' || ch == '[' || ch == '{')
			return StringUtil.getBracket(str, ch);
		if (ch == '\'')
			return StringUtil.getString(str, ch);
		int offs = str.indexOf(" ") == -1 ? str.length() : str.indexOf(" ");
		String separator = " ";
		if (str.indexOf(",") != -1 && str.indexOf(",") < offs) {
			offs = str.indexOf(",");
			separator = ",";
		}
		if (str.indexOf("-") != -1 && str.indexOf("-") < offs) {
			offs = str.indexOf("-");
			separator = "-";
		}
		if (str.indexOf("+") != -1 && str.indexOf("+") < offs) {
			offs = str.indexOf("+");
			separator = "+";
		}
		if (str.indexOf("*") != -1 && str.indexOf("*") < offs) {
			offs = str.indexOf("*");
			separator = "*";
		}
		if (str.indexOf("=") != -1 && str.indexOf("=") < offs) {
			offs = str.indexOf("=");
			separator = "=";
		}
		if (str.indexOf("||") != -1 && str.indexOf("||") < offs) {
			offs = str.indexOf("||");
			separator = "||";
		}
		if (str.indexOf("(") != -1 && str.indexOf("(") < offs) {
			offs = str.indexOf("(");
			return str.substring(0, offs) + StringUtil.getBracket(str.substring(offs), '(');
		}
		if (offs == -1)
			return str;
		if (hasSeparator && offs == 0)
			return separator;
		return str.substring(0, offs);
	}

	/**
	 * 从字符串中取出第一个单词,但将分隔符（'，'、‘ ’）也作为一个单词
	 */
	public static String getFirstWord(String str) throws Exception {
		return StringUtil.getFirstWord(str, false);
	}

	/**
	 * 匹配一个字符串中的第一个刮号. 这里假定该字符串的的刮号是正确的
	 */
	public static String getBracket(String str, char bracketType) throws Exception {
		// 确定刮号的种类
		char endType = ')';
		if (bracketType == '[')
			endType = ']';
		else if (bracketType == '{')
			endType = '}';
		else if (bracketType != '(')
			throw new Exception(bracketType + " not a type of bracket");

		char[] c = str.toCharArray();
		int sum = 1;
		String s = null;
		for (int i = 1; i < c.length; i++) {
			if (c[i] == bracketType) {
				sum++;
				continue;
			}
			if (c[i] == endType) {
				if (--sum == 0) {
					s = String.valueOf(c, 0, i + 1);
					break;
				}
			}
		}
		if (s == null)
			throw new Exception("bracket not suited");
		return s;
	}

	public static String ltrim(String str) {
		char[] c = str.toCharArray();
		for (int i = 0; i < c.length; i++) {
			if (c[i] != ' ') {
				str = String.valueOf(c, i, c.length - i);
				break;
			}
		}
		return str;
	}

	/**
	 * 根据标示符取一个字符串
	 */
	public static String getString(String str, char c) {
		char[] ch = str.toCharArray();
		for (int i = 1; i < ch.length; i++) {
			if (ch[i] == c) {
				if (i == ch.length - 1) {
					str = String.valueOf(ch, 0, i + 1);
					break;
				}
				if (ch[i + 1] != c) {
					str = String.valueOf(ch, 0, i + 1);
					break;
				} else {
					i++;
				}
			}
		}
		return str;
	}

	/**
	 * 转编码
	 **/
	public static String changeCnCode(String oldStr) {
		String value = null;
		try {
			value = new String(oldStr.getBytes("ISO-8859-1"), "GBK");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return value;
	}

	/**
	 * 多个空格替换为一个
	 * 
	 * @param sourceStr
	 * @return
	 */
	public static String repSingleSpace(String sourceStr) {
		String regEx = "['   ']+";

		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(sourceStr);
		return m.replaceAll(" ");
	}

	/**
	 * 字符串为空补0.00
	 * 
	 * @param string
	 * @return
	 */
	public static String toBd0(String str) {
		return str != null ? str : "0.00";
	}

	/**
	 * 半角文字转化为全角
	 * 
	 * @param BJstr 需要转化的半角文字
	 * @return 转化后的全角文字
	 */
	public static final String BQchange(String BJstr) {
		String outStr = "";
		String Tstr = "";
		byte[] b = null;

		for (int i = 0; i < BJstr.length(); i++) {
			try {
				Tstr = BJstr.substring(i, i + 1);
				b = Tstr.getBytes("unicode");
			} catch (java.io.UnsupportedEncodingException e) {
				e.printStackTrace();
			}
			if (b[3] != -1) {
				b[2] = (byte) (b[2] - 32);
				b[3] = -1;
				try {
					outStr = outStr + new String(b, "unicode");
				} catch (java.io.UnsupportedEncodingException e) {
					e.printStackTrace();
				}
			} else
				outStr = outStr + Tstr;
		}
		return outStr;
	}

	/**
	 * 全角文字转化为半角
	 * 
	 * @param QJstr 需要转化的全角文字
	 * @return 转化后的半角文字
	 */
	public static final String QBchange(String QJstr) {
		String outStr = "";
		String Tstr = "";
		byte[] b = null;

		for (int i = 0; i < QJstr.length(); i++) {
			try {
				Tstr = QJstr.substring(i, i + 1);
				b = Tstr.getBytes("unicode");
			} catch (java.io.UnsupportedEncodingException e) {
				e.printStackTrace();
			}
			if (b[3] == -1) {
				b[2] = (byte) (b[2] + 32);
				b[3] = 0;
				try {
					outStr = outStr + new String(b, "unicode");
				} catch (java.io.UnsupportedEncodingException e) {
					e.printStackTrace();
				}
			} else
				outStr = outStr + Tstr;
		}
		return outStr;
	}

	/**
	 * 将Null转化为空字符串
	 * 
	 * @param param 需要转化的字符串
	 * @return 如果为Null则返回空，如果不是则返回原字符串
	 */
	public static Object nullToString(Object param) {
		if (param == null) {
			return "";
		}
		return param;
	}

	/**
	 * 判断字符串是否为null或是空
	 * 
	 * @param param 需要判断的字符串
	 * @return true 是；false：否
	 */
	public static boolean isNullOrNoValue(String param) {
		if (param == null || "".equals(param.trim())) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断字符串不为null且有值
	 * 
	 * @param param 需要判断的字符串
	 * @return true 是；false：否
	 */
	public static boolean isNotNullAndHasValue(String param) {
		if (param != null && !"".equals(param.trim())) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 返回一个字节的十六进制字符串
	 * 
	 * @param b
	 *            字节
	 * @return 十六进制字符串
	 */
	public static String hexByte(byte b) {
		String s = "000000" + Integer.toHexString(b);
		return s.substring(s.length() - 2);
	}

	/**
	 * 将Null或是空字符串转化为"0"
	 * 
	 * @param param 需要转化的字符串
	 * @return 如果为Null或是""则返回"0"，如果不是则返回原字符串
	 */
	public static String defaultNumber(String param) {

		if (param == null) {
			return "0";
		}
		if (param.length() == 0) {
			return "0";
		}
		return param;
	}

	/**
	 * 判断一个数字是否为素数
	 * 
	 * @param param 需要判断的数字
	 * @return true：是素数 false：不是素数
	 */
	public static boolean isPrimes(int param) {
		for (int i = 2; i <= Math.sqrt(param); i++) {
			if (param % i == 0) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 判断是否为整数
	 * 
	 * @param str 传入的字符串
	 * @return 是整数返回true,否则返回false
	 */
	public static boolean isInteger(String str) {
		Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
		return pattern.matcher(str).matches();
	}

	/**
	 * 判断是否为浮点数，包括double和float
	 * 
	 * @param str 传入的字符串
	 * @return 是浮点数返回true,否则返回false
	 */
	public static boolean isDouble(String str) {
		Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
		return pattern.matcher(str).matches();
	}

	/**
	 * 判断输入的字符串是否为纯汉字
	 * 
	 * @param str 传入的字符窜
	 * @return 如果是纯汉字返回true,否则返回false
	 */
	public static boolean isChinese(String str) {
		Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");
		return pattern.matcher(str).matches();
	}

	/**
	 * 判断是否为质数
	 * 
	 * @param x
	 * @return
	 */
	public static boolean isPrime(int x) {
		if (x <= 7) {
			if (x == 2 || x == 3 || x == 5 || x == 7)
				return true;
		}
		int c = 7;
		if (x % 2 == 0)
			return false;
		if (x % 3 == 0)
			return false;
		if (x % 5 == 0)
			return false;
		int end = (int) Math.sqrt(x);
		while (c <= end) {
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 6;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 6;
		}
		return true;
	}

	/**
	 * 人民币转成大写
	 * 
	 * @param value 数字
	 * @return 大写的人民币
	 */
	public static String hangeToBig(double value) {
		char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
		char[] vunit = { '万', '亿' }; // 段名表示
		char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
		long midVal = (long) (value * 100); // 转化成整形
		String valStr = String.valueOf(midVal); // 转化成字符串

		String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
		String rail = valStr.substring(valStr.length() - 2); // 取小数部分

		String prefix = ""; // 整数部分转化的结果
		String suffix = ""; // 小数部分转化的结果
		// 处理小数点后面的数
		if (rail.equals("00")) { // 如果小数部分为0
			suffix = "整";
		} else {
			suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
		}
		// 处理小数点前面的数
		char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
		char zero = '0'; // 标志'0'表示出现过0
		byte zeroSerNum = 0; // 连续出现0的次数
		for (int i = 0; i < chDig.length; i++) { // 循环处理每个数字
			int idx = (chDig.length - i - 1) % 4; // 取段内位置
			int vidx = (chDig.length - i - 1) / 4; // 取段位置
			if (chDig[i] == '0') { // 如果当前字符是0
				zeroSerNum++; // 连续0次数递增
				if (zero == '0') { // 标志
					zero = digit[0];
				} else if (idx == 0 && vidx > 0 && zeroSerNum < 4) {
					prefix += vunit[vidx - 1];
					zero = '0';
				}
				continue;
			}
			zeroSerNum = 0; // 连续0次数清零
			if (zero != '0') { // 如果标志不为0,则加上,例如万,亿什么的
				prefix += zero;
				zero = '0';
			}
			prefix += digit[chDig[i] - '0']; // 转化该数字表示
			if (idx > 0)
				prefix += hunit[idx - 1];
			if (idx == 0 && vidx > 0) {
				prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
			}
		}

		if (prefix.length() > 0)
			prefix += '圆'; // 如果整数部分存在,则有圆的字样
		return prefix + suffix; // 返回正确表示
	}

	/**
	 * 去掉字符串中重复的子字符串
	 * 
	 * @param str
	 * @return String
	 */
	private static String removeSameString(String str) {
		Set<String> mLinkedSet = new LinkedHashSet<String>();
		String[] strArray = str.split(" ");
		StringBuffer sb = new StringBuffer();

		for (int i = 0; i < strArray.length; i++) {
			if (!mLinkedSet.contains(strArray[i])) {
				mLinkedSet.add(strArray[i]);
				sb.append(strArray[i] + " ");
			}
		}
		return sb.toString().substring(0, sb.toString().length() - 1);
	}

	/**
	 * 判断是不是合法手机
	 * 
	 * @param handset 手机号
	 * @return true：合法 false：不合法
	 */
	public static boolean isHandset(String handset) {
		try {
			if (!handset.substring(0, 1).equals("1")) {
				return false;
			}
			if (handset == null || handset.length() != 11) {
				return false;
			}
			String check = "^[0123456789]+$";
			Pattern regex = Pattern.compile(check);
			Matcher matcher = regex.matcher(handset);
			boolean isMatched = matcher.matches();
			if (isMatched) {
				return true;
			} else {
				return false;
			}
		} catch (RuntimeException e) {
			return false;
		}
	}

	/**
	 * 字符串反转
	 * 
	 * @param param
	 * @return
	 */
	public static String CoverseString(String param) {
		String converseString = "";
		for (int i = param.length() - 1; i >= 0; i--) {
			converseString = converseString + param.charAt(i);
		}
		return converseString;
	}

	/*
	 * 功能描述:将数字字符按会计格式整理返回固定长度 formatNumber（"-1400.235",2)=-1,400.24保留两位）
	 * 可以保留小数点后几位,如果不足,补0 如果足,就四舍五入 整数和小数的逗号分割
	 */

	public static String formatNumber(String number, int weishu) throws Exception {
		if (number == null || (number.trim().length() == 0)) {
			return "";
		}
		String first = number.substring(0, 1);
		if ("-".equals(first)) { // 针对数字为负数的情况
			number = number.substring(1);
			return first + formatPositiveNumber(number, weishu);
		} else { // 针对数字为正数的情况
			return formatPositiveNumber(number, weishu);
		}
	}

	/**
	 * 数字格式化
	 * 
	 * @param number 需要格式的数字
	 * @param weishu 小数点位数
	 * @return 格式完成的数字
	 * @throws Exception
	 */
	public static String formatPositiveNumber(String number, int weishu) throws Exception {
		try {
			// 判断字符串是否为空
			if (number == null || (number.trim().length() == 0)) {
				return "";
			}
			// 判断首字符为"."的情况
			String first = number.substring(0, 1);
			if (".".equals(first)) {
				number = "0" + number;
			}
			// 判断字符串里有除点号之外的非数字存在
			char[] strArray = number.toCharArray();
			for (int i = 0; i < strArray.length; i++) {
				if ((strArray[i] < '0' || strArray[i] > '9') && strArray[i] != '.') {
					return number;
				}
			}
			// 判断小数位数为0的情况
			if (number.indexOf(".") != -1 && weishu == 0) {

				int pointNumber = number.indexOf(".");
				String strFirst = number.substring(0, pointNumber);

				// 小数点前字符串分割
				strFirst = splitFirstNumber(strFirst);
				return strFirst;

			}

			// 判断没有小数点，但小数位数要求有位数的情况
			if (number.indexOf(".") == -1 && weishu != 0) {

				number = number + ".";
				for (int i = 0; i < weishu; i++) {
					number = number + "0";
				}

				int pointNumber = number.indexOf(".");
				String strFirst = number.substring(0, pointNumber);
				String strLast = number.substring(pointNumber + 1, number.length());

				// 小数点前字符串分割
				strFirst = splitFirstNumber(strFirst);

				// 小数点后字符串分割
				strLast = splitLastNumber(strLast);

				return strFirst + "." + strLast;

			}

			// 判断没有小数部分的情况
			if ((number.indexOf(".") == -1) && weishu == 0) {

				// 小数点前字符串分割
				number = splitFirstNumber(number);
				return number;
			} else {
				int pointNumber = number.indexOf(".");
				String strFirst = number.substring(0, pointNumber);
				String strLast = number.substring(pointNumber + 1, number.length());

				// 小数位数判断
				strLast = formatPoint(strLast, weishu);

				// 小数点前字符串分割
				strFirst = splitFirstNumber(strFirst);

				// 小数点后字符串分割
				strLast = splitLastNumber(strLast);

				return strFirst + "." + strLast;
			}
		} catch (Exception e) {
			throw new Exception("数字格式出错" + e.getMessage());
		}
	}

	/**
	 * @param str 小数点前的字符串
	 * @return 返回小数点前的逗号分割
	 */
	public static String splitFirstNumber(String str) {
		StringBuffer strBuffer = new StringBuffer();
		strBuffer.append(str);
		strBuffer.reverse();
		str = strBuffer.toString();
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < str.length(); i = i + 3) {
			if (i + 3 < str.length()) {
				String str1 = str.substring(i, i + 3);
				sb.append(str1);
				sb.append(",");
			} else {
				String str2 = str.substring(i, str.length());
				sb.append(str2);
			}
		}
		sb.reverse();
		return sb.toString();
	}

	/**
	 * @param str 小数点后字符串
	 * @return 逗号分割后的字符串
	 */
	public static String splitLastNumber(String str) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < str.length(); i = i + 3) {
			if (i + 3 < str.length()) {
				String str1 = str.substring(i, i + 3);
				sb.append(str1);
				sb.append(",");
			} else {
				String str2 = str.substring(i, str.length());
				sb.append(str2);
			}
		}
		return sb.toString();
	}

	/**
	 * @param laststr 小数点后字符串
	 * @param bitWei 截取的字符串长度
	 * @return 返回小数点后应得的字符串
	 */
	public static String formatPoint(String laststr, int bitWei) {
		int n = laststr.length();
		if (n < bitWei) {
			for (int i = 0; i < bitWei - n; i++) {
				laststr = laststr + "0";
			}
		} else {
			BigDecimal bd = new BigDecimal("0." + laststr).setScale(bitWei, BigDecimal.ROUND_HALF_UP);
			laststr = bd.toString();
			laststr = laststr.substring(2, laststr.length());
		}
		return laststr;
	}

	/**
	 * 验证邮箱
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isEmail(String str) {
		String regex = "^([\\w-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([\\w-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$";
		return match(regex, str);
	}

	/**
	 * 验证IP地址
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isIP(String str) {
		String num = "(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)";
		String regex = "^" + num + "\\." + num + "\\." + num + "\\." + num + "$";
		return match(regex, str);
	}

	/**
	 * 验证网址Url
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isUrl(String str) {
		String regex = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?";
		return match(regex, str);
	}

	/**
	 * 验证电话号码
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isTelephone(String str) {
		String regex = "^(\\d{3,4}-)?\\d{6,8}$";
		return match(regex, str);
	}

	/**
	 * @param regex 正则表达式字符串
	 * @param str 要匹配的字符串
	 * @return 如果str 符合 regex的正则表达式格式,返回true, 否则返回 false;
	 */
	private static boolean match(String regex, String str) {
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(str);
		return matcher.matches();
	}

	/**
	 * 验证输入邮政编号
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isPostalcode(String str) {
		String regex = "^\\d{6}$";
		return match(regex, str);
	}

	/**
	 * 验证输入手机号码
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isMobilePhone(String str) {
		String regex = "^[1]+[3,5,8]+\\d{9}$";
		return match(regex, str);
	}

	/**
	 * 验证输入身份证号
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isIDcard(String str) {
		String regex = "(^\\d{18}$)|(^\\d{15}$)";
		return match(regex, str);
	}

	/**
	 * 验证数字输入
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isNumber(String str) {
		String regex = "^[0-9]*$";
		return match(regex, str);
	}

	/**
	 * 验证非零的正整数
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isIntNumber(String str) {
		String regex = "^\\+?[1-9][0-9]*$";
		return match(regex, str);
	}

	/**
	 * 验证大写字母
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isUpChar(String str) {
		String regex = "^[A-Z]+$";
		return match(regex, str);
	}

	/**
	 * 验证小写字母
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isLowChar(String str) {
		String regex = "^[a-z]+$";
		return match(regex, str);
	}

	/**
	 * 验证验证输入字母
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isLetter(String str) {
		String regex = "^[A-Za-z]+$";
		return match(regex, str);
	}

	/**
	 * 验证验证输入字符串
	 * 
	 * @param 待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isLength(String str) {
		String regex = "^.{8,}$";
		return match(regex, str);
	}

	/**
	 * 数组排序
	 * 
	 * @param list
	 *            需要排序的list
	 */
	public static void sort(Object[] list) {
		Object currentMax;
		int currentMaxIndex;

		for (int i = list.length - 1; i >= 1; i--) {
			currentMax = list[i];
			currentMaxIndex = i;

			for (int j = i - 1; j >= 0; j--) {
				if (((Comparable) currentMax).compareTo(list[j]) < 0) {
					currentMax = list[j];
					currentMaxIndex = j;
				}
			}

		}
	}

	/**
	 * 
	 * 基本功能：过滤所有以"<"开头以">"结尾的标签
	 * <p>
	 * 
	 * @param str
	 * @return String
	 */
	public static String filterHtml(String str) {
		String strTemp = "";
		if (str != null && !"".equals(str)) {
			Pattern pattern = Pattern.compile("<([^>]*)>");
			Matcher matcher = pattern.matcher(str);
			StringBuffer sb = new StringBuffer();
			boolean result1 = matcher.find();
			while (result1) {
				matcher.appendReplacement(sb, "");
				result1 = matcher.find();
			}
			matcher.appendTail(sb);
			strTemp = sb.toString();

		}

		return strTemp;
	}

	/**
	 * 根据分隔符取得最后的字符串
	 * 
	 * @param oldValue
	 * @param spitValue
	 * @return
	 */
	public static String GetLastSpitString(String oldValue, String spitValue) {

		String[] tempArrStrings;
		String tempValueString = "";
		tempArrStrings = oldValue.split(spitValue);

		tempValueString = tempArrStrings[tempArrStrings.length - 1];

		return tempValueString;
	}

	/**
	 * 
	 * <b>Summary: </b> RomoveStringByList(请用一句话描述这个方法的作用)
	 * 
	 * @param oldValue
	 * @param removeValue
	 * @param spitValue
	 * @return
	 */
	public static String RomoveStringByList(String oldValue, String removeValue, String spitValue) {
		String[] tempArrStrings;

		if (isNullOrNoValue(oldValue)) {
			return "";
		}

		String tempValueString = spitValue + oldValue;
		tempArrStrings = oldValue.split(spitValue);

		for (String temp : tempArrStrings) {
			tempValueString = tempValueString.replace(spitValue + temp + spitValue, spitValue);
		}

		if (tempValueString.length() >= 2) {
			return tempValueString.substring(1);
		} else {
			return "";
		}
	}
}
